/*
 * Copyright (C) 2011 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.andware.volley;

import android.os.Handler;

import java.util.concurrent.Executor;

/**
 * Delivers responses and errors.
 */
public class ExecutorDelivery implements ResponseDelivery {
    /**
     * Used for posting responses, typically to the main thread.
     */
    private final Executor mResponsePoster;

    /**
     * Creates a new response delivery interface.
     *
     * @param handler {@link Handler} to post responses on
     */
    public ExecutorDelivery ( final Handler handler ) {
        // Make an Executor that just wraps the handler.
        mResponsePoster = new Executor () {
            @Override
            public void execute ( Runnable command ) {
                handler.post ( command );
            }
        };
    }

    /**
     * Creates a new response delivery interface, mockable version
     * for testing.
     *
     * @param executor For running delivery tasks
     */
    public ExecutorDelivery ( Executor executor ) {
        mResponsePoster = executor;
    }

    @Override
    public void postResponse ( Request< ? > request, Response< ? > response ) {
        postResponse ( request, response, null );
    }

    @Override
    public void postResponse ( Request< ? > request, Response< ? > response, Runnable runnable ) {
        request.markDelivered ();
        request.addMarker ( "post-response" );
        mResponsePoster.execute ( new ResponseDeliveryRunnable ( request, response, runnable ) );
    }

    @Override
    public void postError ( Request< ? > request, VolleyError error ) {
        request.addMarker ( "post-error" );
        Response< ? > response = Response.error ( error );
        mResponsePoster.execute ( new ResponseDeliveryRunnable ( request, response, null ) );
    }

    /**
     * A Runnable used for delivering network responses to a listener on the
     * main thread.
     */
    @SuppressWarnings ( "rawtypes" )
    private class ResponseDeliveryRunnable implements Runnable {
        private final Request mRequest;
        private final Response mResponse;
        private final Runnable mRunnable;

        public ResponseDeliveryRunnable ( Request request, Response response, Runnable runnable ) {
            mRequest = request;
            mResponse = response;
            mRunnable = runnable;
        }

        @SuppressWarnings ( "unchecked" )
        @Override
        public void run () {
            // If this request has canceled, finish it and don't deliver.
            if ( mRequest.isCanceled () ) {
                mRequest.finish ( "canceled-at-delivery" );
                return;
            }

            // Deliver a normal response or error, depending.
            if ( mResponse.isSuccess () ) {
                mRequest.deliverResponse ( mResponse.result );
            } else {
                mRequest.deliverError ( mResponse.error );
            }

            // If this is an intermediate response, add a marker, otherwise we're done
            // and the request can be finished.
            if ( mResponse.intermediate ) {
                mRequest.addMarker ( "intermediate-response" );
            } else {
                mRequest.finish ( "done" );
            }

            // If we have been provided a post-delivery runnable, run it.
            if ( mRunnable != null ) {
                mRunnable.run ();
            }
        }
    }
}
